Nanodegree key: nd013
Version: 1.0.0
Locale: en-us
Work on some of the most cutting-edge technologies and help make the self-driving car revolution a reality!
Content
Part 01 : Computer Vision and Deep Learning
In this term, you'll become an expert in applying Computer Vision and Deep Learning on automotive problems. You will teach the car to detect lane lines, predict steering angle, and more all based on just camera data!
-
Module 01: Introduction
-
Lesson 01: Welcome
Welcome! This lesson will introduce you to the program, help you discover the services we provide, and show you all the incredible projects you'll build!
- Concept 01: Why Self-Driving Cars?
- Concept 02: Meet Your Instructors
- Concept 03: Overview of ND Program
- Concept 04: What Projects Will You Build?
- Concept 05: Nanodegree Support
- Concept 06: Career Support
- Concept 07: Community Code of Conduct
- Concept 08: Deadline Policy
- Concept 09: Class Schedule
- Concept 10: Rating Your Career Confidence
- Concept 11: Self-Driving Car History
- Concept 12: The Great Robot Race (Optional)
- Concept 13: Self-Driving Car Quiz
-
Lesson 02: Workspaces
An introduction to and explanation of Linux-based workspaces that can be interfaced via a shell (BASH).
-
Lesson 03: Computer Vision Fundamentals
In this first lesson, you'll discover some basic computer vision techniques to find lane markings on the road. We’ll dive much deeper into computer vision in later lessons, so relax and have fun!
- Concept 01: Power of Cameras
- Concept 02: Setting up the Problem
- Concept 03: Color Selection
- Concept 04: Color Selection Code Example
- Concept 05: Color Selection
- Concept 06: Region Masking
- Concept 07: Color and Region Combined
- Concept 08: Color Region
- Concept 09: Finding Lines of Any Color
- Concept 10: What is Computer Vision?
- Concept 11: Canny Edge Detection
- Concept 12: Canny to Detect Lane Lines
- Concept 13: Canny Edges
- Concept 14: Hough Transform
- Concept 15: Hough Transform to Find Lane Lines
- Concept 16: Hough Transform
-
Lesson 04: Finding Lane Lines Project
In the first project, apply your new computer vision skills to find lane markings on the road!
-
-
Module 02: Careers: Orientation
-
Lesson 01: Career Services Available to You
As you learn the skills you’ll need in order to work in the autonomous vehicle industry, you’ll see optional Career Lessons and Projects that will help ensure you're best presenting your new skills to potential employers. Meet the Careers team who will help you meet your career goals.
-
-
Module 03: Deep Learning
-
Lesson 01: Introduction to Neural Networks
Learn to build and train neural networks, starting with the foundations in linear and logistic regression, and culminating in backpropagation and multilayer perceptron networks.
- Concept 01: Neural Network Intuition
- Concept 02: Introduction to Deep Learning
- Concept 03: Starting Machine Learning
- Concept 04: A Note on Deep Learning
- Concept 05: Quiz: Housing Prices
- Concept 06: Solution: Housing Prices
- Concept 07: Linear to Logistic Regression
- Concept 08: Classification Problems 1
- Concept 09: Classification Problems 2
- Concept 10: Linear Boundaries
- Concept 11: Higher Dimensions
- Concept 12: Perceptrons
- Concept 13: Perceptrons II
- Concept 14: Why "Neural Networks"?
- Concept 15: Perceptrons as Logical Operators
- Concept 16: Perceptron Trick
- Concept 17: Perceptron Algorithm
- Concept 18: Non-Linear Regions
- Concept 19: Error Functions
- Concept 20: Log-loss Error Function
- Concept 21: Discrete vs Continuous
- Concept 22: Softmax
- Concept 23: One-Hot Encoding
- Concept 24: Maximum Likelihood
- Concept 25: Maximizing Probabilities
- Concept 26: Cross-Entropy 1
- Concept 27: Cross-Entropy 2
- Concept 28: Multi-Class Cross Entropy
- Concept 29: Logistic Regression
- Concept 30: Gradient Descent
- Concept 31: Gradient Descent: The Code
- Concept 32: Perceptron vs Gradient Descent
- Concept 33: Continuous Perceptrons
- Concept 34: Non-linear Data
- Concept 35: Non-Linear Models
- Concept 36: Neural Network Architecture
- Concept 37: Feedforward
- Concept 38: Multilayer Perceptrons
- Concept 39: Backpropagation
- Concept 40: Further Reading
- Concept 41: Create Your Own NN
- Concept 42: Summary
-
Lesson 02: MiniFlow
In this assignment, you will build your own neural network library from scratch! Your library, MiniFlow, will behave much like TensorFlow, Google's deep learning library.
- Concept 01: Introduction to MiniFlow
- Concept 02: Introduction
- Concept 03: Graphs
- Concept 04: MiniFlow Architecture
- Concept 05: Forward Propagation
- Concept 06: Forward Propagation Solution
- Concept 07: Learning and Loss
- Concept 08: Linear Transform
- Concept 09: Sigmoid Function
- Concept 10: Cost
- Concept 11: Gradient Descent Part 1
- Concept 12: Gradient Descent Part 2
- Concept 13: Backpropagation
- Concept 14: Stochastic Gradient Descent
- Concept 15: SGD Solution
- Concept 16: Under the Hood Part 1
- Concept 17: Under the Hood Part 2
- Concept 18: Outro
-
Lesson 03: Introduction to TensorFlow
Vincent Vanhoucke, Principal Scientist at Google Brain, introduces you to deep learning and Tensorflow, Google's deep learning framework.
- Concept 01: Deep Learning Frameworks
- Concept 02: Introduction to Deep Neural Networks
- Concept 03: What is Deep Learning?
- Concept 04: Solving Problems - Big and Small
- Concept 05: Let's Get Started!
- Concept 06: Installing TensorFlow
- Concept 07: Hello, Tensor World!
- Concept 08: Quiz: Tensorflow Input
- Concept 09: Quiz: Tensorflow Math
- Concept 10: Transition to Classification
- Concept 11: Supervised Classification
- Concept 12: Let's make a deal
- Concept 13: Training Your Logistic Classifier
- Concept 14: TensorFlow Linear Function
- Concept 15: Quiz: Linear Function
- Concept 16: Linear Update
- Concept 17: Quiz: Softmax
- Concept 18: Quiz: TensorFlow Softmax Workspaces
- Concept 19: One-Hot Encoding
- Concept 20: Quiz: One-Hot Encoding
- Concept 21: Cross Entropy
- Concept 22: Minimizing Cross Entropy
- Concept 23: Practical Aspects of Learning
- Concept 24: Quiz: Numerical Stability
- Concept 25: Normalized Inputs and Initial Weights
- Concept 26: Measuring Performance
- Concept 27: Transition: Overfitting -> Dataset Size
- Concept 28: Validation and Test Set Size
- Concept 29: Validation Set Size
- Concept 30: Validation Test Set Size Continued
- Concept 31: Optimizing a Logistic Classifier
- Concept 32: Stochastic Gradient Descent
- Concept 33: Momentum and Learning Rate Decay
- Concept 34: Parameter Hyperspace!
- Concept 35: Quiz: Mini-batch
- Concept 36: Quiz 2: Mini-batch
- Concept 37: Epochs
- Concept 38: AWS GPU Instances
- Concept 39: Intro TensorFlow Neural Network
- Concept 40: Lab: Neural Network Workspaces
-
Lesson 04: Deep Neural Networks
Vincent walks you through how to go from a simple neural network to a deep neural network. You'll learn about why additional layers can help and how to prevent overfitting.
- Concept 01: Let's Go Deeper
- Concept 02: Intro to Deep Neural Networks
- Concept 03: Number of Parameters
- Concept 04: Linear Models are Limited
- Concept 05: Rectified Linear Units
- Concept 06: Network of ReLUs
- Concept 07: 2-Layer Neural Network
- Concept 08: Quiz: TensorFlow ReLu
- Concept 09: No Neurons
- Concept 10: The Chain Rule
- Concept 11: Backprop
- Concept 12: Deep Neural Network in TensorFlow
- Concept 13: Training a Deep Learning Network
- Concept 14: Save and Restore TensorFlow Models
- Concept 15: Finetuning
- Concept 16: Regularization Intro
- Concept 17: Regularization
- Concept 18: Regularization Quiz
- Concept 19: Dropout
- Concept 20: Dropout Pt. 2
- Concept 21: Quiz: TensorFlow Dropout
- Concept 22: Quiz 2: TensorFlow Dropout
-
Lesson 05: Convolutional Neural Networks
Vincent explains the theory behind Convolutional Neural Networks and how they help us dramatically improve performance in image classification.
- Concept 01: CNNs Have Taken Over
- Concept 02: Intro To CNNs
- Concept 03: Color
- Concept 04: Statistical Invariance
- Concept 05: Convolutional Networks
- Concept 06: Intuition
- Concept 07: Filters
- Concept 08: Feature Map Sizes
- Concept 09: Convolutions continued
- Concept 10: Parameters
- Concept 11: Quiz: Convolution Output Shape
- Concept 12: Solution: Convolution Output Shape
- Concept 13: Quiz: Number of Parameters
- Concept 14: Solution: Number of Parameters
- Concept 15: Quiz: Parameter Sharing
- Concept 16: Solution: Parameter Sharing
- Concept 17: Visualizing CNNs
- Concept 18: TensorFlow Convolution Layer
- Concept 19: Explore The Design Space
- Concept 20: TensorFlow Max Pooling
- Concept 21: Quiz: Pooling Intuition
- Concept 22: Solution: Pooling Intuition
- Concept 23: Quiz: Pooling Mechanics
- Concept 24: Solution: Pooling Mechanics
- Concept 25: Quiz: Pooling Practice
- Concept 26: Solution: Pooling Practice
- Concept 27: Quiz: Average Pooling
- Concept 28: Solution: Average Pooling
- Concept 29: 1x1 Convolutions
- Concept 30: Inception Module
- Concept 31: Convolutional Network in TensorFlow
- Concept 32: TensorFlow Convolution Layer
- Concept 33: Solution: TensorFlow Convolution Layer
- Concept 34: TensorFlow Pooling Layer
- Concept 35: Solution: TensorFlow Pooling Layer
- Concept 36: Lab: LeNet in TensorFlow
- Concept 37: LeNet Lab Workspace
- Concept 38: CNNs - Additional Resources
-
Lesson 06: LeNet for Traffic Signs
Using the infamous LeNet neural network architecture, take your first steps toward building a Traffic Sign classifier!
- Concept 01: LeNet Architecture
- Concept 02: AWS GPU Instances
- Concept 03: LeNet Data
- Concept 04: LeNet Implementation
- Concept 05: LeNet Training Pipeline
- Concept 06: LeNet Evaluation Pipeline
- Concept 07: LeNet Training the Model
- Concept 08: LeNet Testing
- Concept 09: LeNet on AWS
- Concept 10: LeNet for Traffic Signs
- Concept 11: Visualizing Layers
-
Lesson 07: Traffic Sign Classifier Project
You just finished getting your feet wet with deep learning. Now put your skills to the test by using deep learning to build your own model to classify different traffic signs!
-
Lesson 08: Keras
Take on the neural network framework, Keras. You'll be amazed how few lines of code you'll need to build and train deep neural networks!
- Concept 01: Deep Learning Breakthroughs
- Concept 02: Introduction
- Concept 03: Deep Learning Frameworks
- Concept 04: High Level Frameworks
- Concept 05: Keras Overview
- Concept 06: Neural Networks in Keras
- Concept 07: Convolutions in Keras
- Concept 08: Pooling in Keras
- Concept 09: Dropout in Keras
- Concept 10: Testing in Keras
- Concept 11: Conclusion
-
Lesson 09: Transfer Learning
Learn about some of the most famous neural network architectures and how you can use them. By the end of this lesson, you'll know how to create new models by leveraging existing canonical networks.
- Concept 01: Introduction
- Concept 02: Bryan Catanzaro
- Concept 03: GPU vs. CPU
- Concept 04: Transfer Learning
- Concept 05: Deep Learning History
- Concept 06: ImageNet
- Concept 07: AlexNet
- Concept 08: Lab: AlexNet
- Concept 09: Lab: ImageNet Inference
- Concept 10: Lab: Traffic Sign Inference
- Concept 11: Lab: Solution - Traffic Sign Inference
- Concept 12: Lab: Feature Extraction
- Concept 13: Lab: Solution - Feature Extraction
- Concept 14: Lab: Training the Feature Extractor
- Concept 15: Lab: Solution - Training the Feature Extractor
- Concept 16: Lab: Conclusion
- Concept 17: AlexNet Today
- Concept 18: VGG
- Concept 19: Empirics
- Concept 20: GoogLeNet
- Concept 21: ResNet
- Concept 22: Lab: VGG, Inception (GoogLeNet) and ResNet
- Concept 23: Lab: Cifar10 Aside
- Concept 24: Lab: Feature Extraction with Cifar10
- Concept 25: Lab: Solution - Feature Extraction with Cifar10
- Concept 26: Lab: Feature Extraction with Traffic Signs
- Concept 27: Lab: Solution - Feature Extraction with Traffic Signs
- Concept 28: Lab: Transfer Learning Summary
- Concept 29: Outro
-
Lesson 10: Behavioral Cloning Project
Put your deep learning skills to the test with this project! Train a deep neural network to drive a car like you!
- Concept 01: Vehicle Simulator
- Concept 02: Intro to Behavioral Cloning Project
- Concept 03: Project Resources
- Concept 04: Running the Simulator
- Concept 05: Data Collection Tactics
- Concept 06: Data Collection Strategies
- Concept 07: Data Visualization
- Concept 08: Training the Network
- Concept 09: Running Your Network
- Concept 10: Data Preprocessing
- Concept 11: More Networks
- Concept 12: Data Augmentation
- Concept 13: Using Multiple Cameras
- Concept 14: Cropping Images in Keras
- Concept 15: Even More Powerful Network
- Concept 16: More Data Collection
- Concept 17: Visualizing Loss
- Concept 18: Generators
- Concept 19: Recording Video in Autonomous Mode
- Concept 20: Project Workspace Instructions
- Concept 21: Project Behavioral Cloning
- Concept 22: Share your success - Behavioral Cloning
-
-
Module 04: Computer Vision
-
Lesson 01: Camera Calibration
Learn how to calibrate your camera to remove inherent distortions that can affect its perception of the world.
- Concept 01: The Challenges with Cameras
- Concept 02: Welcome to Computer Vision
- Concept 03: Overview
- Concept 04: Getting Started
- Concept 05: Distortion Correction
- Concept 06: Effects of Distortion
- Concept 07: Pinhole Camera Model
- Concept 08: Image Formation
- Concept 09: Measuring Distortion
- Concept 10: Finding Corners
- Concept 11: Calibrating Your Camera
- Concept 12: Correcting for Distortion
- Concept 13: Lane Curvature
- Concept 14: Perspective Transform
- Concept 15: Curvature and Perspective
- Concept 16: Transform a Stop Sign
- Concept 17: Intuitions
- Concept 18: Undistort and Transform
- Concept 19: How I Did It
- Concept 20: Coming Up
-
Lesson 02: Gradients and Color Spaces
Learn how to use gradient thresholds and different color spaces to more easily identify lane markings on the road.
- Concept 01: Gradient Threshold
- Concept 02: Sobel Operator
- Concept 03: Applying Sobel
- Concept 04: Magnitude of the Gradient
- Concept 05: Direction of the Gradient
- Concept 06: Combining Thresholds
- Concept 07: Color Spaces
- Concept 08: Color Thresholding
- Concept 09: HLS intuitions
- Concept 10: HLS and Color Thresholds
- Concept 11: HLS Quiz
- Concept 12: Color and Gradient
-
Lesson 03: Advanced Techniques for Lane Finding
Discover more advanced computer vision techniques to improve upon your lane lines algorithm!
- Concept 01: Reviewing Steps
- Concept 02: Processing Each Image
- Concept 03: Finding the Lines: Histogram Peaks
- Concept 04: Finding the Lines: Sliding Window
- Concept 05: Finding the Lines: Search from Prior
- Concept 06: Another Sliding Window Search
- Concept 07: Measuring Curvature I
- Concept 08: Measuring Curvature II
-
Lesson 04: Advanced Lane Finding Project
Build a pipeline using distortion correction, image rectification, color transforms, and gradient thresholding to identify lane lines and their curvature in a video.
-
Lesson 05: Machine Learning and Stanley
Learn about classification, training and testing, and run a naive Bayes classifier using Scikit Learn.
- Concept 01: Intro to Classifiers
- Concept 02: ML in The Google Self-Driving Car
- Concept 03: Stanley Terrain Classification
- Concept 04: Speed Scatterplot: Grade and Bumpiness
- Concept 05: Speed Scatterplot 2
- Concept 06: Speed Scatterplot 3
- Concept 07: From Scatterplots to Predictions
- Concept 08: From Scatterplots to Predictions 2
- Concept 09: From Scatterplots to Decision Surfaces
- Concept 10: A Good Linear Decision Surface
- Concept 11: Transition to Using Naive Bayes
- Concept 12: NB Decision Boundary in Python
- Concept 13: Getting Started With sklearn
- Concept 14: Gaussian NB Example
- Concept 15: GaussianNB Deployment on Terrain Data
- Concept 16: Calculating NB Accuracy
- Concept 17: Training and Testing Data
- Concept 18: Naive Bayes Strengths and Weaknesses
- Concept 19: Congrats on Learning Naive Bayes
-
Lesson 06: Support Vector Machines
See how support vector machines work, and code one using Scikit Learn.
- Concept 01: Welcome to SVM
- Concept 02: Separating Line
- Concept 03: Choosing Between Separating Lines
- Concept 04: Maximizing the Margin
- Concept 05: Practice with Margins
- Concept 06: SVMs and Tricky Data Distributions
- Concept 07: SVM Response to Outliers
- Concept 08: SVM Outlier Practice
- Concept 09: Handoff to Katie
- Concept 10: SVM in SKlearn
- Concept 11: Coding Up the SVM
- Concept 12: Nonlinear SVMs
- Concept 13: Nonlinear Data
- Concept 14: A New Feature
- Concept 15: Visualizing the New Feature
- Concept 16: Separating with the New Feature
- Concept 17: Practice Making a New Feature
- Concept 18: Kernel Trick
- Concept 19: Playing Around with Kernel Choices
- Concept 20: Kernel and Gamma
- Concept 21: SVM C Parameter
- Concept 22: SVM Gamma Parameter
- Concept 23: Overfitting
- Concept 24: SVM Strengths and Weaknesses
-
Lesson 07: Decision Trees
Learn about decision trees, including entropy and information gain.
- Concept 01: Welcome To Decision Trees
- Concept 02: Linearly Separable Data
- Concept 03: Multiple Linear Questions
- Concept 04: Constructing a Decision Tree First Split
- Concept 05: Constructing a Decision Tree 2nd Split
- Concept 06: Class Labels After Second Split
- Concept 07: Constructing A Decision Tree/Third Split
- Concept 08: Coding A Decision Tree
- Concept 09: Decision Tree Accuracy
- Concept 10: Decision Tree Parameters
- Concept 11: Min Samples Split
- Concept 12: Decision Tree Accuracy
- Concept 13: Data Impurity and Entropy
- Concept 14: Minimizing Impurity in Splitting
- Concept 15: Formula of Entropy
- Concept 16: Entropy Calculation Part 1
- Concept 17: Entropy Calculation Part 2
- Concept 18: Entropy Calculation Part 3
- Concept 19: Entropy Calculation Part 4
- Concept 20: Entropy Calculation Part 5
- Concept 21: Information Gain
- Concept 22: Information Gain Calculation Part 1
- Concept 23: Information Gain Calculation Part 2
- Concept 24: Information Gain Calculation Part 3
- Concept 25: Information Gain Calculation Part 4
- Concept 26: Information Gain Calculation Part 5
- Concept 27: Information Gain Calculation Part 6
- Concept 28: Information Gain Calculation Part 7
- Concept 29: Information Gain Calculation Part 8
- Concept 30: Information Gain Calculation Part 9
- Concept 31: Information Gain Calculation Part 10
- Concept 32: Tuning Criterion Parameter
- Concept 33: Bias-Variance Dilemma
- Concept 34: DT Strengths and Weaknesses
-
Lesson 08: Object Detection
In this lesson, you'll learn how to detect and track vehicles using color and gradient features and a support vector machine classifier.
- Concept 01: Intro to Vehicle Tracking
- Concept 02: Arpan and Drew
- Concept 03: Finding Cars
- Concept 04: Object Detection Overview
- Concept 05: Manual Vehicle Detection
- Concept 06: Features
- Concept 07: Feature Intuition
- Concept 08: Color Features
- Concept 09: Template Matching
- Concept 10: Template Matching Quiz
- Concept 11: Color Histogram Features
- Concept 12: Histograms of Color
- Concept 13: Histogram Comparison
- Concept 14: Color Spaces
- Concept 15: Explore Color Spaces
- Concept 16: Spatial Binning of Color
- Concept 17: Gradient Features
- Concept 18: HOG Features
- Concept 19: Data Exploration
- Concept 20: scikit-image HOG
- Concept 21: Combining Features
- Concept 22: Combine and Normalize Features
- Concept 23: Build a Classifier
- Concept 24: Labeled Data
- Concept 25: Data Preparation
- Concept 26: Train a Classifier
- Concept 27: Parameter Tuning
- Concept 28: Color Classify
- Concept 29: HOG Classify
- Concept 30: Sliding Windows
- Concept 31: How many windows?
- Concept 32: Sliding Window Implementation
- Concept 33: Multi-scale Windows
- Concept 34: Search and Classify
- Concept 35: Hog Sub-sampling Window Search
- Concept 36: False Positives
- Concept 37: Multiple Detections & False Positives
- Concept 38: Tracking Pipeline
- Concept 39: Summary
- Concept 40: Traditional vs. Deep Learning Approach
-
Lesson 09: Vehicle Detection and Tracking Project
In the final Term 1 project, you'll leverage your object detection abilities toward a video pipeline for vehicle detection and tracking.
-
-
Module 05: Term 2 C++ Readiness
Part 02 : Sensor Fusion, Localization, and Control
In this term, you'll learn how to use an array of sensor data to perceive the environment and control the vehicle. You'll evaluate sensor data from camera, radar, lidar, and GPS, and use these in closed-loop controllers that actuate the vehicle.
-
Module 01: Introduction to Term 2
-
Lesson 01: Welcome
Congratulations once more on completing term 1! Your diligent studying and newly honed skills have brought you one major step closer to graduating the program and getting into the field. Today, you begin Term 2, and we can't wait for you to jump in.
-
-
Module 02: Sensor Fusion
-
Lesson 01: Introduction and Sensors
Meet the team at Mercedes who will help you track objects in real-time with Sensor Fusion.
-
Lesson 02: Kalman Filters
Learn from the best! Sebastian Thrun will walk you through the usage and concepts of a Kalman Filter using Python.
- Concept 01: Introduction
- Concept 02: Tracking Intro
- Concept 03: Gaussian Intro
- Concept 04: Variance Comparison
- Concept 05: Preferred Gaussian
- Concept 06: Evaluate Gaussian
- Concept 07: Maximize Gaussian
- Concept 08: Measurement and Motion
- Concept 09: Shifting the Mean
- Concept 10: Predicting the Peak
- Concept 11: Parameter Update
- Concept 12: Parameter Update 2
- Concept 13: Separated Gaussians
- Concept 14: Separated Gaussians 2
- Concept 15: New Mean and Variance
- Concept 16: Gaussian Motion
- Concept 17: Predict Function
- Concept 18: Kalman Filter Code
- Concept 19: Kalman Prediction
- Concept 20: Kalman Filter Land
- Concept 21: Kalman Filter Prediciton
- Concept 22: Another Prediction
- Concept 23: More Kalman Filters
- Concept 24: Kalman Filter Design
- Concept 25: Kalman Matrices
- Concept 26: Conclusion
-
Lesson 03: C++ Checkpoint
Are you ready to build Kalman Filters with C++? Take these quizzes to find out.
- Concept 01: High Performance Computing
- Concept 02: [Optional] Beta Test our Upcoming C++ Course
- Concept 03: Challenge 1
- Concept 04: Challenge 1 Solution
- Concept 05: Challenge 2
- Concept 06: Challenge 2 Solution
- Concept 07: Challenge 3
- Concept 08: Challenge 3 Solution
- Concept 09: Challenge 4
- Concept 10: Challenge 4 Solution
- Concept 11: Challenge 5
- Concept 12: Challenge 5 Solution
- Concept 13: Outro and Advice
-
Lesson 04: Lidar and Radar Fusion with Kalman Filters in C++
In this lesson, you'll build a Kalman Filter in C++ that's capable of handling data from multiple sources. Why C++? Its performance enables the application of object tracking with a Kalman Filter in real-time.
- Concept 01: Kalman Filters in C++
- Concept 02: Intro
- Concept 03: Lesson Map and Fusion Flow
- Concept 04: Lesson Variables and Equations
- Concept 05: Estimation Problem Refresh
- Concept 06: Kalman Filter Intuition
- Concept 07: Kalman Filter Equations in C++ Part 1
- Concept 08: Kalman Filter Equations in C++ Part 2
- Concept 09: State Prediction
- Concept 10: Process Covariance Matrix
- Concept 11: Laser Measurements Part 1
- Concept 12: Laser Measurements Part 2
- Concept 13: Laser Measurements Part 3
- Concept 14: Laser Measurements Part 4
- Concept 15: Radar Measurements
- Concept 16: Mapping with a Nonlinear Function
- Concept 17: Extended Kalman Filter
- Concept 18: Multivariate Taylor Series Expansion
- Concept 19: Jacobian Matrix Part 1
- Concept 20: Jacobian Matrix Part 2
- Concept 21: EKF Algorithm Generalization
- Concept 22: Sensor Fusion General Flow
- Concept 23: Evaluating KF Performance Part 1
- Concept 24: Evaluating KF Performance 2
- Concept 25: Outro
-
Lesson 05: Extended Kalman Filter Project
In this project, you'll apply everything you've learned so far about Sensor Fusion by implementing an Extended Kalman Filter in C++!
- Concept 01: Back to Bayes Theorem
- Concept 02: Intro to Extended Kalman Filter Project
- Concept 03: Data File
- Concept 04: File Structure
- Concept 05: Main.cpp
- Concept 06: Project Code
- Concept 07: Tips and Tricks
- Concept 08: Project Resources
- Concept 09: Project Instructions for workspaces
- Concept 10: Project Extended Kalman Filter GPU
- Concept 11: Project Instructions for local setup
- Concept 12: uWebSocketIO Starter Guide
- Concept 13: Environment Setup (Windows)
- Concept 14: Environment Setup (Linux)
- Concept 15: Environment Setup (Mac)
- Concept 16: Compiling and Running the Project
-
Lesson 06: Unscented Kalman Filters
While Extended Kalman Filters work great for linear motion, real objects rarely move linearly. With Unscented Kalman Filters, you'll be able to accurately track non-linear motion!
- Concept 01: Introduction
- Concept 02: The CTRV Model
- Concept 03: The CTRV Model State Vector
- Concept 04: CTRV Differential Equation
- Concept 05: CTRV Integral 1
- Concept 06: CTRV Integral 2
- Concept 07: CTRV Zero Yaw Rate
- Concept 08: CTRV Process Noise Vector
- Concept 09: CTRV Process Noise Position
- Concept 10: UKF Process Chain
- Concept 11: What Problem Does the UKF Solve?
- Concept 12: UKF Basics Unscented Transformation
- Concept 13: Generating Sigma Points
- Concept 14: Generating Sigma Points Assignment 1
- Concept 15: Generating Sigma Points Assignment 2
- Concept 16: UKF Augmentation
- Concept 17: Augmentation Assignment 1
- Concept 18: Augmentation Assignment 2
- Concept 19: Sigma Point Prediction
- Concept 20: Sigma Point Prediction Assignment 1
- Concept 21: Sigma Point Prediction Assignment 2
- Concept 22: Predicted Mean and Covariance
- Concept 23: Predicted Mean and Covariance Assignment 1
- Concept 24: Predicted Mean and Covariance Assignment 2
- Concept 25: Measurement Prediction
- Concept 26: Predict Radar Measurement Assignment 1
- Concept 27: Predict Radar Measurement Assignment 2
- Concept 28: UKF Update
- Concept 29: UKF Update Assignment 1
- Concept 30: UKF Update Assignment 2
- Concept 31: Parameters and Consistency
- Concept 32: What to Expect from the Project
- Concept 33: Story Time
- Concept 34: Outro
-
Lesson 07: Unscented Kalman Filter Project
Put your skills to the test! Use C++ to code an Unscented Kalman Filter capable of tracking non-linear motion.
-
-
Module 03: Localization
-
Lesson 01: Introduction to Localization
Meet the team that will guide you through the localization lessons!
-
Lesson 02: Localization Overview
Sebastian Thrun will give you an overview of the theory behind localization!
- Concept 01: Introduction
- Concept 02: Localization
- Concept 03: Total Probability
- Concept 04: Uniform Probability Quiz
- Concept 05: Uniform Distribution
- Concept 06: Generalized Uniform Distribution
- Concept 07: Probability After Sense
- Concept 08: Compute Sum
- Concept 09: Normalize Distribution
- Concept 10: pHit and pMiss
- Concept 11: Sum of Probabilities
- Concept 12: Sense Function
- Concept 13: Normalized Sense Function
- Concept 14: Test Sense Function
- Concept 15: Multiple Measurements
- Concept 16: Lesson Breakpoint
- Concept 17: Exact Motion
- Concept 18: Move Function
- Concept 19: Inexact Motion 1
- Concept 20: Inexact Motion 2
- Concept 21: Inexact Motion 3
- Concept 22: Inexact Move Function
- Concept 23: Limit Distribution Quiz
- Concept 24: Move Twice
- Concept 25: Move 1000
- Concept 26: Sense and Move
- Concept 27: Sense and Move 2
- Concept 28: Localization Summary
- Concept 29: Formal Definition of Probability 1
- Concept 30: Formal Definition of Probability 2
- Concept 31: Formal Definition of Probability 3
- Concept 32: Bayes' Rule
- Concept 33: Cancer Test
- Concept 34: Theorem of Total Probability
- Concept 35: Coin Flip Quiz
- Concept 36: Two Coin Quiz
-
Lesson 03: Markov Localization
In this lesson, you'll learn the math behind localization as well as how to implement Markov localization in C++.
- Concept 01: Return to Bayes' Rule
- Concept 02: Overview
- Concept 03: Localization Posterior: Introduction
- Concept 04: Localization Posterior Explanation and Implementation
- Concept 05: Bayes' Rule
- Concept 06: Bayes' Filter For Localization
- Concept 07: Calculate Localization Posterior
- Concept 08: Initialize Belief State
- Concept 09: Initialize Priors Function
- Concept 10: Solution: Initialize Priors Function
- Concept 11: Quiz: How Much Data?
- Concept 12: How Much Data: Explanation
- Concept 13: Derivation Outline
- Concept 14: Apply Bayes Rule with Additional Conditions
- Concept 15: Bayes Rule and Law of Total Probability
- Concept 16: Total Probability and Markov Assumption
- Concept 17: Markov Assumption for Motion Model: Quiz
- Concept 18: Markov Assumption for Motion Model: Explanation
- Concept 19: After Applying Markov Assumption: Quiz
- Concept 20: Recursive Structure
- Concept 21: Lesson Breakpoint
- Concept 22: Implementation Details for Motion Model
- Concept 23: Noise in Motion Model: Quiz
- Concept 24: Noise in Motion Model: Solution
- Concept 25: Determine Probabilities
- Concept 26: Motion Model Probabiity I
- Concept 27: Motion Model Probability II
- Concept 28: Coding the Motion Model
- Concept 29: Solution: Coding the Motion Model
- Concept 30: Observation Model Introduction
- Concept 31: Markov Assumption for Observation Model
- Concept 32: Finalize the Bayes Localization Filter
- Concept 33: Bayes Filter Theory Summary
- Concept 34: Observation Model Probability
- Concept 35: Get Pseudo Ranges
- Concept 36: Solution: Get Pseudo Ranges
- Concept 37: Coding the Observation Model
- Concept 38: Solution: Coding the Observation Model
- Concept 39: Coding the Full Filter
- Concept 40: Solution: Coding the Full Filter
- Concept 41: Conclusion
-
Lesson 04: Motion Models
Here you'll learn about vehicle movement and motion models to predict where your car will be at a future time.
- Concept 01: Motion in Autonomy
- Concept 02: Lesson Introduction
- Concept 03: Motion Models: Bicycle Model
- Concept 04: Yaw Rate and Velocity
- Concept 05: Note on Frames of Reference
- Concept 06: Roll, Pitch and Yaw: Quiz
- Concept 07: Odometry
- Concept 08: Odometry Errors: Quiz
- Concept 09: Odometry Errors: Solution
- Concept 10: Conclusion
-
Lesson 05: Particle Filters
Now, Sebastian will teach you what a particle filter is and will teach the theory and math behind the particle filter.
- Concept 01: Field Trip
- Concept 02: State Space
- Concept 03: Belief Modality
- Concept 04: Efficiency
- Concept 05: Exact or Approximate
- Concept 06: Particle Filters
- Concept 07: Using Robot Class
- Concept 08: Robot Class Details
- Concept 09: Moving Robot
- Concept 10: Add Noise
- Concept 11: Robot World
- Concept 12: Creating Particles
- Concept 13: Robot Particles
- Concept 14: Importance Weight
- Concept 15: Resampling
- Concept 16: Never Sampled 1
- Concept 17: Never Sampled 2
- Concept 18: Never Sampled 3
- Concept 19: New Particle
- Concept 20: Resampling Wheel
- Concept 21: Orientation 1
- Concept 22: Orientation 2
- Concept 23: Error
- Concept 24: You and Sebastian
- Concept 25: Filters
- Concept 26: 2012
-
Lesson 06: Implementation of a Particle Filter
Now that you understand how a particle filter works, you'll learn how to code a particle filter.
- Concept 01: Particle Filters in C++
- Concept 02: Introduction
- Concept 03: Pseudocode
- Concept 04: Initialization
- Concept 05: Program Gaussian Sampling: Code
- Concept 06: Program Gaussian Sampling: Code Solution
- Concept 07: Prediction Step
- Concept 08: Calculate Prediction Step: Quiz
- Concept 09: Calculate Prediction Step Quiz Explanation
- Concept 10: Data Association: Nearest Neighbor
- Concept 11: Nearest Neighbor Advantages and Disadvantages
- Concept 12: Update Step
- Concept 13: Calculating Error
- Concept 14: Transformations and Associations
- Concept 15: Converting Landmark Observations
- Concept 16: Quiz: Landmarks
- Concept 17: Landmarks Quiz Solution
- Concept 18: Quiz: Association
- Concept 19: Quiz: Particle Weights
- Concept 20: Particle Weights Solution
- Concept 21: Explanation of Project Code
-
Lesson 07: Kidnapped Vehicle Project
In this project, you'll build a particle filter and combine it with a real map to localize a vehicle!
-
-
Module 04: Control
-
Lesson 01: PID Control
In this lesson you'll learn about and how to use PID controllers with Sebastian!
- Concept 01: Intro
- Concept 02: PID Control
- Concept 03: Proportional Control
- Concept 04: Implement P Controller
- Concept 05: P Controller Solution
- Concept 06: Oscillations
- Concept 07: PD Controller
- Concept 08: PD Controller Solution
- Concept 09: Systematic Bias
- Concept 10: Is PD Enough
- Concept 11: PID implementation
- Concept 12: PID Implementation Solution
- Concept 13: Twiddle
- Concept 14: Parameter Optimization
- Concept 15: Parameter Optimization Solution
- Concept 16: Outro
-
Lesson 02: PID Controller Project
Implement a PID Controller to race around the lake track.
-
Lesson 03: Vehicle Models
In this lesson, you'll learn about kinematic and dynamic vehicle models. We'll use these later with Model Predictive Control.
- Concept 01: Intro
- Concept 02: Vehicle Models
- Concept 03: State
- Concept 04: Building a Kinematic Model
- Concept 05: Global Kinematic Model
- Concept 06: Solution: Global Kinematic Model
- Concept 07: Following Trajectories
- Concept 08: Fitting Polynomials
- Concept 09: Solution: Fitting Polynomials
- Concept 10: Errors
- Concept 11: Dynamic Models
- Concept 12: Dynamic Models - Forces
- Concept 13: Dynamic Models - Slip Angle
- Concept 14: Dynamic Models - Slip Ratio
- Concept 15: Dynamic Models - Tire Models
- Concept 16: Actuator Constraints
- Concept 17: Outro
-
Lesson 04: Model Predictive Control
In this lesson, you'll learn how to frame the control problem as an optimization problem over time horizons. This is Model Predictive Control!
- Concept 01: Intro
- Concept 02: Reference State
- Concept 03: Dealing With Stopping
- Concept 04: Additional Cost Considerations
- Concept 05: Length and Duration
- Concept 06: Putting It All Together
- Concept 07: Latency
- Concept 08: Mind The Line
- Concept 09: Solution: Mind The Line
- Concept 10: Tuning MPC
- Concept 11: Outro
-
Lesson 05: Model Predictive Control Project
In this project, you'll implement Model Predictive Control to drive the vehicle around the track even with additional latency between commands!
-
-
Module 05: Supporting Content
-
Lesson 01: Geometry and Trigonometry Refresher
This optional content is designed to refresh knowledge of trigonometry and geometry, in support of Self Driving Car Engineer term 2 objectives.
- Concept 01: About this Lesson
- Concept 02: Two Dimensional Robot Motion and Trigonometry
- Concept 03: Lesson Introduction
- Concept 04: Plotting Robot Motion (right angles only)
- Concept 05: Plotting Robot Motion Solution
- Concept 06: Moving at an Angle
- Concept 07: Moving at 53.13 Degrees
- Concept 08: Who Cares About 53.13 Degrees?
- Concept 09: The Power of Trigonometry
- Concept 10: Opposite, Adjacent, Hypotenuse
- Concept 11: Trigonometric Ratios
- Concept 12: Looking up Sin, Cos, and Tan
- Concept 13: Trigonometry and Vehicle Motion
- Concept 14: Solving Trig Problems
- Concept 15: Keeping Track of x and y
- Concept 16: Keeping Track of x and y (solution)
- Concept 17: Conclusion
-
Part 03 : Path Planning, Concentrations, and Systems
In this term, you'll learn how to plan where the vehicle should go, how the vehicle systems work together to get it there, and you'll perform a deep-dive into a concentration of your choice.
-
Module 01: Introduction to Term 3
-
Lesson 01: Welcome
Welcome to Term 3! This term includes path planning, an elective concentration, and system integration, which is the capstone of the program. You'll run your code on Udacity's own self-driving car!
-
-
Module 02: Path Planning
-
Lesson 01: Search
In this lesson you will learn about discrete path planning and algorithms for solving the path planning problem.
- Concept 01: Motion Planning
- Concept 02: Introduction to Path Planning
- Concept 03: About this Lesson
- Concept 04: Motion Planning
- Concept 05: Compute Cost
- Concept 06: Compute Cost 2
- Concept 07: Optimal Path
- Concept 08: Optimal Path 2
- Concept 09: Maze
- Concept 10: Maze 2
- Concept 11: First Search Program
- Concept 12: Expansion Grid
- Concept 13: Print Path
- Concept 14: A*
- Concept 15: Implement A*
- Concept 16: A* in Action
- Concept 17: Dynamic Programming
- Concept 18: Computing Value
- Concept 19: Computing Value 2
- Concept 20: Value Program
- Concept 21: Optimum Policy
- Concept 22: Left Turn Policy
- Concept 23: Planning Conclusion
-
Lesson 02: Prediction
In this lesson you'll learn how to use data from sensor fusion to generate predictions about the likely behavior of moving objects.
- Concept 01: Introduction and Overview
- Concept 02: I/O Recap
- Concept 03: Model-Based vs Data-Driven Approaches
- Concept 04: Which is Best?
- Concept 05: Data Driven Example - Trajectory Clustering
- Concept 06: Trajectory Clustering 2 - Online Prediction
- Concept 07: Thinking about Model Based Approaches
- Concept 08: Frenet Coordinates
- Concept 09: Process Models
- Concept 10: More on Process Models
- Concept 11: Multimodal Estimation
- Concept 12: Summary of Data Driven and Model Based Approaches
- Concept 13: Overview of Hybrid Approaches
- Concept 14: Intro to Naive Bayes
- Concept 15: Naive Bayes Quiz
- Concept 16: Implement Naive Bayes C++
- Concept 17: Implement Naive Bayes C++ (solution)
- Concept 18: Conclusion
-
Lesson 03: Behavior Planning
In this lesson you'll learn how to think about high level behavior planning in a self driving car.
- Concept 01: Where To
- Concept 02: Lesson Outline
- Concept 03: Understanding Output
- Concept 04: The Behavior Problem
- Concept 05: Finite State Machines
- Concept 06: Formalizing Finite State Machines
- Concept 07: FSM Intuition
- Concept 08: States for Self Driving Cars
- Concept 09: The States We'll Use
- Concept 10: Inputs to Transition Functions
- Concept 11: Behavior Planning Pseudocode
- Concept 12: Create a Cost Function - Speed Penalty
- Concept 13: Example Cost Function - Lane Change Penalty
- Concept 14: Implement a Cost Function in C++
- Concept 15: Implement a Cost Function in C++ (solution)
- Concept 16: Implement a Second Cost Function in C++
- Concept 17: Implement a Second Cost Function in C++ (solution)
- Concept 18: Cost Function Design and Weight Tweaking
- Concept 19: Cost Function Matching
- Concept 20: Scheduling Compute Time
- Concept 21: Implement Behavior Planner in C++
- Concept 22: Implement Behavior Planner in C++ (solution)
- Concept 23: Conclusion
-
Lesson 04: Trajectory Generation
In this lesson, you’ll use C++ and the Eigen linear algebra library to build candidate trajectories for the vehicle to follow.
- Concept 01: From Behavior to Trajectory
- Concept 02: Lesson Overview
- Concept 03: The Motion Planning Problem
- Concept 04: Properties of Motion Planning Algorithms
- Concept 05: Types of Motion Planning Algorithms
- Concept 06: A* Reminder
- Concept 07: A* Reminder Solution
- Concept 08: Hybrid A* Introduction
- Concept 09: Hybrid A* Tradeoffs
- Concept 10: Hybrid A* Tradeoffs Solution
- Concept 11: Hybrid A* in Practice
- Concept 12: Hybrid A* Heuristics
- Concept 13: Hybrid A* Pseudocode
- Concept 14: Implement Hybrid A* in C++
- Concept 15: Implement Hybrid A* in C++ (solution)
- Concept 16: Environment Classification
- Concept 17: Frenet Reminder
- Concept 18: The Need for Time
- Concept 19: s, d, and t
- Concept 20: Trajectory Matching
- Concept 21: Structured Trajectory Generation Overview
- Concept 22: Trajectories with Boundary Conditions
- Concept 23: Jerk Minimizing Trajectories
- Concept 24: Derivation Overview
- Concept 25: Derivation Details 2
- Concept 26: Polynomial Trajectory Generation
- Concept 27: Implement Quintic Polynomial Solver C++
- Concept 28: Implement Quintic Polynomial Solver Solution
- Concept 29: What should be checked?
- Concept 30: Implementing Feasibility
- Concept 31: Putting it All Together
- Concept 32: Polynomial Trajectory Reading (optional)
- Concept 33: Polynomial Trajectory Generation Playground
- Concept 34: Conclusion
-
Lesson 05: Path Planning Project
Drive a car down a highway with other cars using your own path planner.
-
Lesson 06: Coming Up: Electives
An overview of the elective options and how to proceed.
-
-
Module 03: Elective: Advanced Deep Learning
-
Lesson 01: Elective: Advanced Deep Learning
Students in this specialization, built with the NVIDIA Deep Learning Institute, will learn about semantic segmentation, and inference optimization, active areas of deep learning research.
-
Lesson 02: Fully Convolutional Networks
In this lesson you'll learn the motivation for Fully Convolutional Networks and how they are structured.
- Concept 01: Intro
- Concept 02: Why Fully Convolutional Networks (FCNs) ?
- Concept 03: Fully Convolutional Networks
- Concept 04: Fully Connected to 1x1 Convolution
- Concept 05: 1x1 Convolution Quiz
- Concept 06: 1x1 Convolution Quiz Solution
- Concept 07: Transposed Convolutions
- Concept 08: Transposed Convolution Quiz
- Concept 09: Transposed Convolution Quiz Solution
- Concept 10: Skip Connections
- Concept 11: FCNs In The Wild
- Concept 12: Outro
-
Lesson 03: Scene Understanding
In this lesson you'll be introduced to the problem of Scene Understanding and the role FCNs play.
- Concept 01: Intro
- Concept 02: Bounding Boxes
- Concept 03: Semantic Segmentation
- Concept 04: Scene Understanding
- Concept 05: IoU
- Concept 06: IOU Example
- Concept 07: IoU Quiz
- Concept 08: IOU Solution
- Concept 09: FCN-8 - Encoder
- Concept 10: FCN-8 - Decoder
- Concept 11: FCN-8 - Classification & Loss
- Concept 12: Object Detection Lab
- Concept 13: Outro
-
Lesson 04: Inference Performance
In this lesson you'll become familiar with various optimizations in an effort to squeeze every last bit of performance at inference.
- Concept 01: Intro
- Concept 02: Why Bother With Performance
- Concept 03: Semantic Segmentation Revisited
- Concept 04: Interlude: Using The AMI
- Concept 05: Freezing Graphs
- Concept 06: Graph Transforms
- Concept 07: Fusion
- Concept 08: Optimizing For Inference
- Concept 09: Reducing Precision
- Concept 10: Quantization Quiz
- Concept 11: Quantization Conversion
- Concept 12: 8-bit Calculations
- Concept 13: Compilation
- Concept 14: AOT & JIT
- Concept 15: Reusing The Graph
- Concept 16: Outro
-
Lesson 05: Semantic Segmentation Project
Train segmentation networks, which paint each pixel of the image a different color, based on its class. Use segmented images to find free space on the road.
-
-
Module 04: Elective: Functional Safety
-
Lesson 01: Elective: Functional Safety
If you choose the Functional Safety specialization, built with Elektrobit, you’ll learn functional safety frameworks to ensure that vehicles are safe, both at the system and component levels.
-
Lesson 02: Introduction to Functional Safety
You will learn to make safer vehicles using risk evaluation and systems engineering.
- Concept 01: Introduction to the Functional Safety Module
- Concept 02: Introduction to the Lesson
- Concept 03: What is Safety?
- Concept 04: What is Functional Safety?
- Concept 05: Introduction to Identifying Hazards
- Concept 06: Sebastian and Technology Errors
- Concept 07: Introduction to Evaluating Risks
- Concept 08: Reducing Risk with Systems Engineering
- Concept 09: Introduction to ISO 26262
- Concept 10: The Full V Model
- Concept 11: Summary
- Concept 12: Sebastian Talks About Self-Driving Car Risks
-
Lesson 03: Functional Safety: Safety Plan
A functional safety plan is critical to any functional safety project. Here you will learn what goes into a safety plan so that you can document your own.
-
Lesson 04: Functional Safety: Hazard Analysis and Risk Assessment
In a hazard analysis and risk assessment, you will identify vehicular malfunctions and evaluate their risk levels. You can then derive safety goals defining how your vehicle will remain safe.
- Concept 01: Introduction
- Concept 02: Advanced Driver Assistance System
- Concept 03: Item Definition
- Concept 04: Introduction to Hazard Analysis and Risk Assessment
- Concept 05: Sebastian Discussing Hazards
- Concept 06: Situational Analysis
- Concept 07: Identification of Hazards
- Concept 08: Risk Assessment, Severity, Exposure, Controllability
- Concept 09: Automotive Safety Integrity Levels (ASIL)
- Concept 10: Safety Goals
- Concept 11: Lesson Summary
-
Lesson 05: Functional Safety: Functional Safety Concept
You will derive functional safety requirements from the safety goals and then add extra functionality to the system diagram. Finally you document your work, a part of functional safety.
- Concept 01: Introduction
- Concept 02: Functional Safety Analysis
- Concept 03: Functional Safety Requirements
- Concept 04: Allocation to the Architecture
- Concept 05: Architecture Refinement
- Concept 06: ASIL Inheritance
- Concept 07: ASIL Decomposition
- Concept 08: Fault Tolerant Time Interval
- Concept 09: Warning and Degradation Concept
- Concept 10: Verification and Validation Acceptance Criteria
- Concept 11: Sebastian On Requirements and Testing
- Concept 12: Summary
-
Lesson 06: Functional Safety: Technical Safety Concept
Once you have derived functional safety requirements, you drill down into more detail. In the technical safety concept, you refine your requirements into technical safety requirements.
- Concept 01: Introduction
- Concept 02: Deriving Technical Safety Requirements
- Concept 03: Other Types of Technical Safety Requirements
- Concept 04: Technical Safety Requirement Attributes
- Concept 05: Allocation of Requirements to System Architecture Elements
- Concept 06: Sebastian on Testing
- Concept 07: Summary
-
Lesson 07: Functional Safety at the Software and Hardware Levels
The last step in the vehicle safety design phase is to derive hardware and software safety requirements. In this lesson, you will derive these requirements and refine a software system architecture.
- Concept 01: Introduction
- Concept 02: V model
- Concept 03: Hardware Failure Metrics
- Concept 04: Programming Languages
- Concept 05: MISRA C++ Lab
- Concept 06: Software Safety Life-cycle
- Concept 07: Software Safety Requirements Lane Departure Warning
- Concept 08: Other Sources of Software Safety Requirements
- Concept 09: Freedom from Interference - Spatial
- Concept 10: Freedom from Interference - Temporal
- Concept 11: Freedom from Interference - Temporal Part 2
- Concept 12: Sebastian and Temporal Interference
- Concept 13: Freedom from Interference - Communication
- Concept 14: System Architecture Safety Design Patterns
- Concept 15: Lesson Summary
- Concept 16: Module Summary
-
Lesson 08: Elective Project: Functional Safety
It's time to start the functional safety project! You will be creating a safety case for a lane assistance system.
Project Description - Functional Safety of a Lane Assistance System
Project Rubric - Functional Safety of a Lane Assistance System
-
-
Module 05: System Integration
-
Lesson 01: Autonomous Vehicle Architecture
Learn about the system architecture for Carla, Udacity's autonomous vehicle.
- Concept 01: Putting it All Together
- Concept 02: Introduction
- Concept 03: The Sensor Subsystem
- Concept 04: The Perception Subsystem
- Concept 05: Perception Subsystem Components
- Concept 06: The Planning Subsystem
- Concept 07: Planning Subsystem Components
- Concept 08: The Control Subsystem
- Concept 09: On to the code!
-
Lesson 02: Introduction to ROS
Obtain an architectural overview of the Robot Operating System Framework and setup your own ROS environment on your computer.
- Concept 01: Communication Between Systems
- Concept 02: Introduction
- Concept 03: Welcome to ROS Essentials
- Concept 04: Build Robots with ROS
- Concept 05: Brief History of ROS
- Concept 06: Nodes and Topics
- Concept 07: Message Passing
- Concept 08: Services
- Concept 09: Compute Graph
- Concept 10: Turtlesim Overview
- Concept 11: ROS Workspace Instructions
- Concept 12: ROS Workspace
- Concept 13: Your Virtual Machine
- Concept 14: Source the ROS Environment
- Concept 15: Run Turtlesim
- Concept 16: Turtlesim Comms: List Nodes
- Concept 17: Turtlesim Comms: List Topics
- Concept 18: Turtlesim Comms: Get Topic Info
- Concept 19: Turtlesim Comms: Message Information
- Concept 20: Turtlesim Comms: Echo a Topic
- Concept 21: Recap
-
Lesson 03: Packages & Catkin Workspaces
Learn about ROS workspace structure, essential command line utilities, and how to manage software packages within a project. Harnessing these will be key to building shippable software using ROS.
-
Lesson 04: Writing ROS Nodes
ROS Nodes are a key abstraction that allows a robot system to be built modularly. In this lesson, you'll learn how to write them using Python.
- Concept 01: Closing In
- Concept 02: Overview
- Concept 03: ROS Publishers
- Concept 04: Simple Mover
- Concept 05: Simple Mover: The Code
- Concept 06: ROS Services
- Concept 07: Arm Mover
- Concept 08: Arm Mover: The Code
- Concept 09: Arm Mover: Launch and Interact
- Concept 10: ROS Subscribers
- Concept 11: Look Away
- Concept 12: Look Away: The Code
- Concept 13: Look Away: Launch and Interact
- Concept 14: Logging
- Concept 15: Recap
- Concept 16: Outro
-
Lesson 05: System Integration Project
Run your code on Carla, Udacity's autonomous vehicle!
- Concept 01: Have Fun!
- Concept 02: Introduction
- Concept 03: Getting Started
- Concept 04: Project Overview
- Concept 05: Waypoint Updater Node (Partial)
- Concept 06: Waypoint Updater Partial Walkthrough
- Concept 07: DBW Node
- Concept 08: DBW Walkthrough
- Concept 09: Traffic Light Detection Node
- Concept 10: Detection Walkthrough
- Concept 11: Waypoint Updater Node (Full)
- Concept 12: Full Waypoint Walkthrough
- Concept 13: Project Workspace Instructions
- Concept 14: Project Submission and Getting Feedback
- Concept 15: Capstone Project Workspace
-
-
Module 06: Completing the Program
-
Lesson 01: Completing the Program
Congratulations! You've reached the end of the Self-Driving Car Engineer Nanodegree program! Read on to learn how to officially complete the program and graduate.
-
Part 04 (Career): Career: Job Search Strategies
Opportunity can come when you least expect it, so when your dream job comes along, you want to be ready. In the following lessons, you will learn strategies for conducting a successful job search, including developing a targeted resume and cover letter for that job.
-
Module 01: Conduct a Job Search
-
Lesson 01: Conduct a Job Search
Learn how to search for jobs effectively through industry research, and targeting your application to a specific role.
-
-
Module 02: Refine Your Resume
-
Lesson 01: Refine Your Entry-Level Resume
Receive a personalized review of your resume. This resume review is best suited for applicants who have 0-3 years of work experience in any industry.
-
Lesson 02: Refine Your Career Change Resume
Receive a personalized review of your resume. This resume review is best suited for applicants who have 3+ years of work experience in an unrelated field.
-
Lesson 03: Refine Your Prior Industry Experience Resume
Receive a personalized review of your resume. This resume review is best suited for applicants who have 3+ years of work experience in a related field.
Project Description - Resume Review Project (Prior Industry Experience)
Project Rubric - Resume Review Project (Prior Industry Experience)
- Concept 01: Convey Your Skills Concisely
- Concept 02: Effective Resume Components
- Concept 03: Resume Structure
- Concept 04: Describe Your Work Experiences
- Concept 05: Resume Reflection
- Concept 06: Resume Review
- Concept 07: Resume Review (Prior Industry Experience)
- Concept 08: Resources in Your Career Portal
-
-
Module 03: Write an Effective Cover Letter
-
Lesson 01: Craft Your Cover Letter
Get a personalized review of your cover letter. A successful cover letter will convey your enthusiasm, specific technical qualifications, and communication skills applicable to the position.
-
Part 05 (Career): Career: Networking
Networking is a very important component to a successful job search. In the following lesson, you will learn how tell your unique story to recruiters in a succinct and professional but relatable way.
-
Module 01: Strengthen Your Online Presence Using LinkedIn
-
Lesson 01: Develop Your Personal Brand
In this lesson, learn how to tell your unique story in a succinct and professional way. Communicate to employers that you know how to solve problems, overcome challenges, and achieve results.
-
Lesson 02: LinkedIn Review
Optimize your LinkedIn profile to show up in recruiter searches, build your network, and attract employers. Learn to read your LinkedIn profile through the lens of a recruiter or hiring manager.
-
Lesson 03: Udacity Professional Profile Review
Update and personalize your Udacity Professional Profile as you complete your Nanodegree program, and make your Profile visible to Udacity hiring partners when you’re ready to start your job search.
-
-
Module 02: GitHub Profile Review
-
Lesson 01: GitHub Profile Review
Review how your GitHub profile, projects, and code represent you as a potential job candidate. Learn to assess your GitHub profile through the eyes of a recruiter or hiring manager.
- Concept 01: Introduction
- Concept 02: GitHub profile important items
- Concept 03: Good GitHub repository
- Concept 04: Interview with Art - Part 1
- Concept 05: Identify fixes for example “bad” profile
- Concept 06: Quick Fixes #1
- Concept 07: Quick Fixes #2
- Concept 08: Writing READMEs with Walter
- Concept 09: Interview with Art - Part 2
- Concept 10: Commit messages best practices
- Concept 11: Reflect on your commit messages
- Concept 12: Participating in open source projects
- Concept 13: Interview with Art - Part 3
- Concept 14: Participating in open source projects 2
- Concept 15: Starring interesting repositories
- Concept 16: Outro
-
Part 06 (Career): Career: Technical Interview
Learn the skills technical interviewers expect you to know—efficiency, common algorithms, manipulating popular data structures, and how to explain a solution.
-
Module 01: Prepare for a Technical Interview
-
Lesson 01: Introduction and Efficiency
Begin the section on data structures and algorithms, including Python and efficiency practice.
- Concept 01: Course Introduction
- Concept 02: Course Outline
- Concept 03: Course Expectations
- Concept 04: Syntax
- Concept 05: Python Practice
- Concept 06: Python: The Basics
- Concept 07: Efficiency
- Concept 08: Notation Intro
- Concept 09: Notation Continued
- Concept 10: Worst Case and Approximation
- Concept 11: Efficiency Practice
-
Lesson 02: List-Based Collections
Learn the definition of a list in computer science, and see definitions and examples of list-based data structures, arrays, linked lists, stacks, and queues.
- Concept 01: Welcome to Collections
- Concept 02: Lists
- Concept 03: Arrays
- Concept 04: Python Lists
- Concept 05: Linked Lists
- Concept 06: Linked Lists in Depth
- Concept 07: Linked List Practice
- Concept 08: Stacks
- Concept 09: Stacks Details
- Concept 10: Stack Practice
- Concept 11: Queues
- Concept 12: Queue Practice
-
Lesson 03: Searching and Sorting
Explore how to search and sort with list-based data structures, including binary search and bubble, merge, and quick sort. Learn how to use recursion.
- Concept 01: Binary Search
- Concept 02: Efficiency of Binary Search
- Concept 03: Binary Search Practice
- Concept 04: Recursion
- Concept 05: Recursion Practice
- Concept 06: Intro to Sorting
- Concept 07: Bubble Sort
- Concept 08: Efficiency of Bubble Sort
- Concept 09: Bubble Sort Practice
- Concept 10: Merge Sort
- Concept 11: Efficiency of Merge Sort
- Concept 12: Merge Sort Practice
- Concept 13: Quick Sort
- Concept 14: Efficiency of Quick Sort
- Concept 15: Quick Sort Practice
-
Lesson 04: Maps and Hashing
Understand the concepts of sets, maps (dictionaries), and hashing. Examine common problems and approaches to hashing, and practice with examples.
-
Lesson 05: Trees
Learn the concepts and terminology associated with tree data structures. Investigate tree types, such as binary search trees, heaps, and self-balancing trees.
- Concept 01: Trees
- Concept 02: Tree Basics
- Concept 03: Tree Terminology
- Concept 04: Tree Practice
- Concept 05: Tree Traversal
- Concept 06: Depth-First Traversals
- Concept 07: Tree Traversal Practice
- Concept 08: Search and Delete
- Concept 09: Insert
- Concept 10: Binary Search Trees
- Concept 11: Binary Tree Practice
- Concept 12: BSTs
- Concept 13: BST Complications
- Concept 14: BST Practice
- Concept 15: Heaps
- Concept 16: Heapify
- Concept 17: Heap Implementation
- Concept 18: Self-Balancing Trees
- Concept 19: Red-Black Trees - Insertion
- Concept 20: Tree Rotations
-
Lesson 06: Graphs
Examine the theoretical concept of a graph and understand common graph terms, coded representations, properties, traversals, and paths.
- Concept 01: Graph Introduction
- Concept 02: What Is a Graph?
- Concept 03: Directions and Cycles
- Concept 04: Connectivity
- Concept 05: Graph Practice
- Concept 06: Graph Representations
- Concept 07: Adjacency Matrices
- Concept 08: Graph Representation Practice
- Concept 09: Graph Traversal
- Concept 10: DFS
- Concept 11: BFS
- Concept 12: Graph Traversal Practice
- Concept 13: Eulerian Path
-
Lesson 07: Case Studies in Algorithms
Explore famous computer science problems, specifically the Shortest Path Problem, the Knapsack Problem, and the Traveling Salesman Problem.
-
Lesson 08: Technical Interviewing Techniques
Learn about the “algorithm” for answering common technical interviewing questions. Practice and get tips for giving interviewers what they’re looking for.
- Concept 01: Interview Introduction
- Concept 02: Clarifying the Question
- Concept 03: Confirming Inputs
- Concept 04: Test Cases
- Concept 05: Brainstorming
- Concept 06: Runtime Analysis
- Concept 07: Coding
- Concept 08: Debugging
- Concept 09: Interview Wrap-Up
- Concept 10: Time for Live Practice with Pramp
- Concept 11: Next Steps
-